define('ace/mode/lisp_highlight_rules', ['require', 'exports', 'module', 'ace/lib/oop', 'ace/mode/text_highlight_rules'], function(require, exports, module) {
  'use strict'

  var oop = require('../lib/oop')
  var TextHighlightRules = require('./text_highlight_rules').TextHighlightRules

  var LispHighlightRules = function() {
    var keywordControl = 'case|do|let|loop|if|else|when'
    var keywordOperator = 'eq|neq|and|or'
    var constantLanguage = 'null|nil'
    var supportFunctions = 'cons|car|cdr|cond|lambda|format|setq|setf|quote|eval|append|list|listp|memberp|t|load|progn'

    var keywordMapper = this.createKeywordMapper({
      'keyword.control': keywordControl,
      'keyword.operator': keywordOperator,
      'constant.language': constantLanguage,
      'support.function': supportFunctions
    }, 'identifier', true)
    this.$rules =
        {
          'start': [
            {
              token: 'comment',
              regex: ';.*$'
            },
            {
              token: ['storage.type.function-type.lisp', 'text', 'entity.name.function.lisp'],
              regex: '(?:\\b(?:(defun|defmethod|defmacro))\\b)(\\s+)((?:\\w|\\-|\\!|\\?)*)'
            },
            {
              token: ['punctuation.definition.constant.character.lisp', 'constant.character.lisp'],
              regex: "(#)((?:\\w|[\\\\+-=<>'\"&#])+)"
            },
            {
              token: ['punctuation.definition.variable.lisp', 'variable.other.global.lisp', 'punctuation.definition.variable.lisp'],
              regex: '(\\*)(\\S*)(\\*)'
            },
            {
              token: 'constant.numeric', // hex
              regex: '0[xX][0-9a-fA-F]+(?:L|l|UL|ul|u|U|F|f|ll|LL|ull|ULL)?\\b'
            },
            {
              token: 'constant.numeric', // float
              regex: '[+-]?\\d+(?:(?:\\.\\d*)?(?:[eE][+-]?\\d+)?)?(?:L|l|UL|ul|u|U|F|f|ll|LL|ull|ULL)?\\b'
            },
            {
              token: keywordMapper,
              regex: '[a-zA-Z_$][a-zA-Z0-9_$]*\\b'
            },
            {
              token: 'string',
              regex: '"(?=.)',
              next: 'qqstring'
            }
          ],
          'qqstring': [
            {
              token: 'constant.character.escape.lisp',
              regex: '\\\\.'
            },
            {
              token: 'string',
              regex: '[^"\\\\]+'
            }, {
              token: 'string',
              regex: '\\\\$',
              next: 'qqstring'
            }, {
              token: 'string',
              regex: '"|$',
              next: 'start'
            }
          ]
        }
  }

  oop.inherits(LispHighlightRules, TextHighlightRules)

  exports.LispHighlightRules = LispHighlightRules
})

define('ace/mode/lisp', ['require', 'exports', 'module', 'ace/lib/oop', 'ace/mode/text', 'ace/mode/lisp_highlight_rules'], function(require, exports, module) {
  'use strict'

  var oop = require('../lib/oop')
  var TextMode = require('./text').Mode
  var LispHighlightRules = require('./lisp_highlight_rules').LispHighlightRules

  var Mode = function() {
    this.HighlightRules = LispHighlightRules
    this.$behaviour = this.$defaultBehaviour
  }
  oop.inherits(Mode, TextMode);

  (function() {
    this.lineCommentStart = ';'

    this.$id = 'ace/mode/lisp'
  }).call(Mode.prototype)

  exports.Mode = Mode
});
(function() {
  window.require(['ace/mode/lisp'], function(m) {
    if (typeof module === 'object' && typeof exports === 'object' && module) {
      module.exports = m
    }
  })
})()
